/**
 * AI大模型集成模块
 * 支持多种大模型API调用：OpenAI GPT、Claude、文心一言等
 */

class AIModelIntegration {
    constructor() {
        this.models = {
            'openai': {
                name: 'OpenAI GPT',
                endpoint: 'https://api.openai.com/v1/chat/completions',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': 'Bearer YOUR_OPENAI_API_KEY'
                }
            },
            'claude': {
                name: 'Claude (Anthropic)',
                endpoint: 'https://api.anthropic.com/v1/messages',
                headers: {
                    'Content-Type': 'application/json',
                    'x-api-key': 'YOUR_ANTHROPIC_API_KEY',
                    'anthropic-version': '2023-06-01'
                }
            },
            'ernie': {
                name: '文心一言 (百度)',
                endpoint: 'https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions',
                headers: {
                    'Content-Type': 'application/json'
                }
            },
            'local': {
                name: '本地模型 (模拟)',
                endpoint: '/api/ai-diagnosis',
                headers: {
                    'Content-Type': 'application/json'
                }
            }
        };
        
        this.currentModel = 'local'; // 默认使用本地模拟模型
        this.config = this.loadConfig();
    }

    /**
     * 加载配置
     */
    loadConfig() {
        try {
            const savedConfig = localStorage.getItem('ai_model_config');
            if (savedConfig) {
                return JSON.parse(savedConfig);
            }
        } catch (error) {
            console.warn('加载AI模型配置失败，使用默认配置:', error);
        }
        
        return {
            model: 'local',
            apiKeys: {},
            temperature: 0.7,
            maxTokens: 1000
        };
    }

    /**
     * 保存配置
     */
    saveConfig() {
        try {
            localStorage.setItem('ai_model_config', JSON.stringify(this.config));
        } catch (error) {
            console.error('保存AI模型配置失败:', error);
        }
    }

    /**
     * 设置API密钥
     */
    setApiKey(model, apiKey) {
        this.config.apiKeys[model] = apiKey;
        this.saveConfig();
        
        // 更新模型配置中的API密钥
        if (this.models[model]) {
            if (model === 'openai') {
                this.models[model].headers.Authorization = `Bearer ${apiKey}`;
            } else if (model === 'claude') {
                this.models[model].headers['x-api-key'] = apiKey;
            }
        }
    }

    /**
     * 切换模型
     */
    switchModel(modelName) {
        if (this.models[modelName]) {
            this.currentModel = modelName;
            this.config.model = modelName;
            this.saveConfig();
            console.log(`切换到模型: ${this.models[modelName].name}`);
            return true;
        }
        console.error(`未知模型: ${modelName}`);
        return false;
    }

    /**
     * 构建医疗诊断提示词
     */
    buildMedicalPrompt(symptoms, additionalInfo = '') {
        const symptomList = Array.isArray(symptoms) ? symptoms.join(', ') : symptoms;
        
        return `你是一个专业的医疗AI助手。请根据以下症状信息进行初步诊断分析：

患者症状：${symptomList}
${additionalInfo ? `附加信息：${additionalInfo}` : ''}

请按照以下格式提供专业的诊断建议：
1. 可能的疾病分析（按可能性排序）
2. 建议的检查项目
3. 生活建议和注意事项
4. 是否需要立即就医

请用中文回答，保持专业、准确、谨慎的态度。注意：这只是初步建议，不能替代专业医生的诊断。`;
    }

    /**
     * 调用OpenAI GPT模型
     */
    async callOpenAI(prompt) {
        const modelConfig = this.models.openai;
        const requestBody = {
            model: 'gpt-3.5-turbo',
            messages: [
                {
                    role: 'system',
                    content: '你是一个专业的医疗AI助手，请提供准确、谨慎的医疗建议。'
                },
                {
                    role: 'user',
                    content: prompt
                }
            ],
            temperature: this.config.temperature,
            max_tokens: this.config.maxTokens
        };

        try {
            const response = await fetch(modelConfig.endpoint, {
                method: 'POST',
                headers: modelConfig.headers,
                body: JSON.stringify(requestBody)
            });

            if (!response.ok) {
                throw new Error(`OpenAI API错误: ${response.status}`);
            }

            const data = await response.json();
            return data.choices[0].message.content;
        } catch (error) {
            console.error('OpenAI API调用失败:', error);
            throw error;
        }
    }

    /**
     * 调用Claude模型
     */
    async callClaude(prompt) {
        const modelConfig = this.models.claude;
        const requestBody = {
            model: 'claude-3-sonnet-20240229',
            max_tokens: this.config.maxTokens,
            temperature: this.config.temperature,
            messages: [
                {
                    role: 'user',
                    content: prompt
                }
            ]
        };

        try {
            const response = await fetch(modelConfig.endpoint, {
                method: 'POST',
                headers: modelConfig.headers,
                body: JSON.stringify(requestBody)
            });

            if (!response.ok) {
                throw new Error(`Claude API错误: ${response.status}`);
            }

            const data = await response.json();
            return data.content[0].text;
        } catch (error) {
            console.error('Claude API调用失败:', error);
            throw error;
        }
    }

    /**
     * 调用文心一言模型
     */
    async callErnie(prompt) {
        const modelConfig = this.models.ernie;
        const accessToken = this.config.apiKeys.ernie || 'YOUR_ERNIE_ACCESS_TOKEN';
        
        const requestBody = {
            messages: [
                {
                    role: 'user',
                    content: prompt
                }
            ],
            temperature: this.config.temperature,
            max_tokens: this.config.maxTokens
        };

        try {
            const endpoint = `${modelConfig.endpoint}?access_token=${accessToken}`;
            const response = await fetch(endpoint, {
                method: 'POST',
                headers: modelConfig.headers,
                body: JSON.stringify(requestBody)
            });

            if (!response.ok) {
                throw new Error(`文心一言API错误: ${response.status}`);
            }

            const data = await response.json();
            return data.result;
        } catch (error) {
            console.error('文心一言API调用失败:', error);
            throw error;
        }
    }

    /**
     * 调用本地模拟模型（降级方案）
     */
    async callLocalModel(symptoms, additionalInfo = '') {
        // 模拟AI处理延迟
        await new Promise(resolve => setTimeout(resolve, 2000));
        
        const symptomList = Array.isArray(symptoms) ? symptoms.join(', ') : symptoms;
        
        // 基于症状关键词的简单匹配
        const symptomLower = symptomList.toLowerCase();
        
        if (symptomLower.includes('头痛') && symptomLower.includes('发热')) {
            return `基于您描述的症状"${symptomList}"，AI初步分析如下：

1. 可能的疾病分析：
   - 上呼吸道感染（可能性较高）
   - 流行性感冒
   - 病毒性感冒

2. 建议检查项目：
   - 体温测量
   - 血常规检查
   - 呼吸道病原体检测

3. 生活建议：
   - 多休息，保证充足睡眠
   - 多喝水，保持水分摄入
   - 清淡饮食，避免辛辣刺激食物

4. 就医建议：
   - 如果体温持续超过38.5℃或症状加重，建议及时就医
   - 注意观察是否有其他症状出现`;
        } else if (symptomLower.includes('咳嗽') && symptomLower.includes('胸闷')) {
            return `基于您描述的症状"${symptomList}"，AI初步分析如下：

1. 可能的疾病分析：
   - 支气管炎（可能性较高）
   - 肺炎
   - 哮喘急性发作

2. 建议检查项目：
   - 胸部X光检查
   - 肺功能测试
   - 血氧饱和度检测

3. 生活建议：
   - 避免吸烟和二手烟
   - 保持室内空气流通
   - 适当休息，避免剧烈运动

4. 就医建议：
   - 如果出现呼吸困难或胸痛加重，请立即就医
   - 建议尽快进行专业检查确诊`;
        } else {
            return `基于您描述的症状"${symptomList}"，AI初步分析如下：

1. 可能的疾病分析：
   - 需要更多症状信息进行准确判断
   - 建议详细描述症状的持续时间、严重程度等

2. 建议检查项目：
   - 基础体格检查
   - 根据具体症状选择相应专科检查

3. 生活建议：
   - 注意休息，观察症状变化
   - 记录症状发展情况

4. 就医建议：
   - 建议咨询专业医生进行详细诊断
   - 如果症状持续或加重，请及时就医`;
        }
    }

    /**
     * 主要的AI诊断方法
     */
    async aiDiagnosis(symptoms, additionalInfo = '') {
        const prompt = this.buildMedicalPrompt(symptoms, additionalInfo);
        
        try {
            let result;
            
            switch (this.currentModel) {
                case 'openai':
                    result = await this.callOpenAI(prompt);
                    break;
                case 'claude':
                    result = await this.callClaude(prompt);
                    break;
                case 'ernie':
                    result = await this.callErnie(prompt);
                    break;
                case 'local':
                default:
                    result = await this.callLocalModel(symptoms, additionalInfo);
                    break;
            }
            
            return {
                success: true,
                model: this.models[this.currentModel].name,
                diagnosis: result,
                timestamp: new Date().toISOString()
            };
            
        } catch (error) {
            console.error('AI诊断失败，使用本地模型降级:', error);
            
            // 降级到本地模型
            try {
                const fallbackResult = await this.callLocalModel(symptoms, additionalInfo);
                return {
                    success: true,
                    model: '本地模型（降级）',
                    diagnosis: fallbackResult,
                    timestamp: new Date().toISOString(),
                    fallback: true
                };
            } catch (fallbackError) {
                return {
                    success: false,
                    error: 'AI诊断服务暂时不可用，请稍后重试',
                    timestamp: new Date().toISOString()
                };
            }
        }
    }

    /**
     * 获取支持的模型列表
     */
    getAvailableModels() {
        return Object.keys(this.models).map(key => ({
            id: key,
            name: this.models[key].name,
            isCurrent: key === this.currentModel
        }));
    }

    /**
     * 获取当前模型信息
     */
    getCurrentModelInfo() {
        return {
            id: this.currentModel,
            name: this.models[this.currentModel].name,
            config: this.config
        };
    }
}

// 创建全局实例
window.aiModel = new AIModelIntegration();